home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 16 / CU Amiga Magazine's Super CD-ROM 16 (1997-10-16)(EMAP Images)(GB)[!][issue 1997-11].iso / CUCD / Graphics / Ghostscript / source / zdouble.c < prev    next >
C/C++ Source or Header  |  1996-03-19  |  12KB  |  489 lines
  1. /* Copyright (C) 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* zdouble.c */
  20. /* Double-precision floating point arithmetic operators */
  21. #include "math_.h"
  22. #include "memory_.h"
  23. #include "string_.h"
  24. #include "ctype_.h"
  25. #include "ghost.h"
  26. #include "gxfarith.h"
  27. #include "errors.h"
  28. #include "oper.h"
  29. #include "store.h"
  30.  
  31. /*
  32.  * Thanks to Jean-Pierre Demailly of the Institut Fourier of the
  33.  * Universit\'e de Grenoble I <demailly@fourier.grenet.fr> for proposing
  34.  * this package and for arranging the funding for its creation.
  35.  *
  36.  * These operators work with doubles represented as 8-byte strings.  When
  37.  * applicable, they write their result into a string supplied as an argument.
  38.  * They also accept ints and reals as arguments.
  39.  */
  40.  
  41. /******
  42.  ****** Time expended: 2.75 hours.
  43.  ******/
  44.  
  45. /* Forward references */
  46. private int near double_params_result(P3(os_ptr, int, double *));
  47. private int near double_params(P3(os_ptr, int, double *));
  48. private int near double_result(P3(os_ptr, int, double));
  49. private int near double_unary(P2(os_ptr, double (*)(P1(double))));
  50.  
  51. #define dbegin_unary()\
  52.     double num;\
  53.     int code = double_params_result(op, 1, &num);\
  54.     if ( code < 0 )\
  55.       return code
  56.  
  57. #define dbegin_binary()\
  58.     double num[2];\
  59.     int code = double_params_result(op, 2, num);\
  60.     if ( code < 0 )\
  61.       return code
  62.  
  63. /* ------ Arithmetic ------ */
  64.  
  65. /* <dnum1> <dnum2> <dresult> .dadd <dresult> */
  66. private int
  67. zdadd(os_ptr op)
  68. {    dbegin_binary();
  69.     return double_result(op, 2, num[0] + num[1]);
  70. }
  71.  
  72. /* <dnum1> <dnum2> <dresult> .ddiv <dresult> */
  73. private int
  74. zddiv(os_ptr op)
  75. {    dbegin_binary();
  76.     if ( num[1] == 0.0 )
  77.       return_error(e_undefinedresult);
  78.     return double_result(op, 2, num[0] / num[1]);
  79. }
  80.  
  81. /* <dnum1> <dnum2> <dresult> .dmul <dresult> */
  82. private int
  83. zdmul(os_ptr op)
  84. {    dbegin_binary();
  85.     return double_result(op, 2, num[0] * num[1]);
  86. }
  87.  
  88. /* <dnum1> <dnum2> <dresult> .dsub <dresult> */
  89. private int
  90. zdsub(os_ptr op)
  91. {    dbegin_binary();
  92.     return double_result(op, 2, num[0] - num[1]);
  93. }
  94.  
  95. /* ------ Simple functions ------ */
  96.  
  97. /* <dnum> <dresult> .dabs <dresult> */
  98. private int
  99. zdabs(os_ptr op)
  100. {    return double_unary(op, fabs);
  101. }
  102.  
  103. /* <dnum> <dresult> .dceiling <dresult> */
  104. private int
  105. zdceiling(os_ptr op)
  106. {    return double_unary(op, ceil);
  107. }
  108.  
  109. /* <dnum> <dresult> .dfloor <dresult> */
  110. private int
  111. zdfloor(os_ptr op)
  112. {    return double_unary(op, floor);
  113. }
  114.  
  115. /* <dnum> <dresult> .dneg <dresult> */
  116. private int
  117. zdneg(os_ptr op)
  118. {    dbegin_unary();
  119.     return double_result(op, 1, -num);
  120. }
  121.  
  122. /* <dnum> <dresult> .dround <dresult> */
  123. private int
  124. zdround(os_ptr op)
  125. {    dbegin_unary();
  126.     return double_result(op, 1, floor(num + 0.5));
  127. }
  128.  
  129. /* <dnum> <dresult> .dsqrt <dresult> */
  130. private int
  131. zdsqrt(os_ptr op)
  132. {    dbegin_unary();
  133.     if ( num < 0.0 )
  134.       return_error(e_rangecheck);
  135.     return double_result(op, 1, sqrt(num));
  136. }
  137.  
  138. /* <dnum> <dresult> .dtruncate <dresult> */
  139. private int
  140. zdtruncate(os_ptr op)
  141. {    dbegin_unary();
  142.     return double_result(op, 1, (num < 0 ? ceil(num) : floor(num)));
  143. }
  144.  
  145. /* ------ Transcendental functions ------ */
  146.  
  147. private int near
  148. darc(os_ptr op, double (*afunc)(P1(double)))
  149. {    dbegin_unary();
  150.     return double_result(op, 1, (*afunc)(num) * radians_to_degrees);
  151. }
  152. /* <dnum> <dresult> .darccos <dresult> */
  153. private int
  154. zdarccos(os_ptr op)
  155. {    return darc(op, acos);
  156. }
  157. /* <dnum> <dresult> .darcsin <dresult> */
  158. private int
  159. zdarcsin(os_ptr op)
  160. {    return darc(op, asin);
  161. }
  162.  
  163. /* <dnum> <ddenom> <dresult> .datan <dresult> */
  164. private int
  165. zdatan(register os_ptr op)
  166. {    double result;
  167.     dbegin_binary();
  168.     if ( num[0] == 0 )        /* on X-axis, special case */
  169.        {    if ( num[1] == 0 )
  170.           return_error(e_undefinedresult);
  171.         result = (num[1] < 0 ? 180 : 0);
  172.        }
  173.     else
  174.        {    result = atan2(num[0], num[1]) * radians_to_degrees;
  175.         if ( result < 0 )
  176.           result += 360;
  177.        }
  178.     return double_result(op, 2, result);
  179. }
  180.  
  181. /* <dnum> <dresult> .dcos <dresult> */
  182. private int
  183. zdcos(os_ptr op)
  184. {    return double_unary(op, gs_cos_degrees);
  185. }
  186.  
  187. /* <dbase> <dexponent> <dresult> .dexp <dresult> */
  188. private int
  189. zdexp(os_ptr op)
  190. {    double ipart;
  191.     dbegin_binary();
  192.     if ( num[0] == 0.0 && num[1] == 0.0 )
  193.       return_error(e_undefinedresult);
  194.     if ( num[0] < 0.0 && modf(num[1], &ipart) != 0.0 )
  195.       return_error(e_undefinedresult);
  196.     return double_result(op, 2, pow(num[0], num[1]));
  197. }
  198.  
  199. private int near
  200. dlog(os_ptr op, double (*lfunc)(P1(double)))
  201. {    dbegin_unary();
  202.     if ( num <= 0.0 )
  203.       return_error(e_rangecheck);
  204.     return double_result(op, 1, (*lfunc)(num));
  205. }
  206. /* <dposnum> <dresult> .dln <dresult> */
  207. private int
  208. zdln(os_ptr op)
  209. {    return dlog(op, log);
  210. }
  211. /* <dposnum> <dresult> .dlog <dresult> */
  212. private int
  213. zdlog(os_ptr op)
  214. {    return dlog(op, log10);
  215. }
  216.  
  217. /* <dnum> <dresult> .dsin <dresult> */
  218. private int
  219. zdsin(os_ptr op)
  220. {    return double_unary(op, gs_sin_degrees);
  221. }
  222.  
  223. /* ------ Comparison ------ */
  224.  
  225. private int near
  226. dcompare(os_ptr op, int mask)
  227. {    double num[2];
  228.     int code = double_params(op, 2, num);
  229.     if ( code < 0 )
  230.       return code;
  231.     make_bool(op - 1,
  232.           (mask & (num[0] < num[1] ? 1 : num[0] > num[1] ? 4 : 2))
  233.            != 0);
  234.     pop(1);
  235.     return 0;
  236. }
  237. /* <dnum1> <dnum2> .deq <bool> */
  238. private int
  239. zdeq(os_ptr op)
  240. {    return dcompare(op, 2);
  241. }
  242. /* <dnum1> <dnum2> .dge <bool> */
  243. private int
  244. zdge(os_ptr op)
  245. {    return dcompare(op, 6);
  246. }
  247. /* <dnum1> <dnum2> .dgt <bool> */
  248. private int
  249. zdgt(os_ptr op)
  250. {    return dcompare(op, 4);
  251. }
  252. /* <dnum1> <dnum2> .dle <bool> */
  253. private int
  254. zdle(os_ptr op)
  255. {    return dcompare(op, 3);
  256. }
  257. /* <dnum1> <dnum2> .dlt <bool> */
  258. private int
  259. zdlt(os_ptr op)
  260. {    return dcompare(op, 1);
  261. }
  262. /* <dnum1> <dnum2> .dne <bool> */
  263. private int
  264. zdne(os_ptr op)
  265. {    return dcompare(op, 5);
  266. }
  267.  
  268. /* ------ Conversion ------ */
  269.  
  270. /* Take the easy way out.... */
  271. #define max_chars 50
  272.  
  273. /* <dnum> <dresult> .cvd <dresult> */
  274. private int
  275. zcvd(os_ptr op)
  276. {    dbegin_unary();
  277.     return double_result(op, 1, num);
  278. }
  279.  
  280. /* <string> <dresult> .cvsd <dresult> */
  281. private int
  282. zcvsd(os_ptr op)
  283. {    int code = double_params_result(op, 0, NULL);
  284.     double num;
  285.     char buf[max_chars + 2];
  286.     char *str = buf;
  287.     uint len;
  288.     char end;
  289.  
  290.     if ( code < 0 )
  291.       return code;
  292.     check_read_type(op[-1], t_string);
  293.     len = r_size(op - 1);
  294.     if ( len > max_chars )
  295.       return_error(e_limitcheck);
  296.     memcpy(str, op[-1].value.bytes, len);
  297.     /*
  298.      * We check syntax in the following way: we remove whitespace,
  299.      * verify that the string contains only [0123456789+-.dDeE],
  300.      * then append a $ and then check that the next character after
  301.      * the scanned number is a $.
  302.      */
  303.     while ( len > 0 && isspace(*str) )
  304.       ++str, --len;
  305.     while ( len > 0 && isspace(str[len - 1]) )
  306.       --len;
  307.     str[len] = 0;
  308.     if ( strspn(str, "0123456789+-.dDeE") != len )
  309.       return_error(e_syntaxerror);
  310.     strcat(str, "$");
  311.     if ( sscanf(str, "%lf%c", &num, &end) != 2 || end != '$' )
  312.       return_error(e_syntaxerror);
  313.     return double_result(op, 1, num);
  314. }
  315.  
  316. /* <dnum> .dcvi <int> */
  317. private int
  318. zdcvi(os_ptr op)
  319. {
  320. #define alt_min_long (-1L << (arch_sizeof_long * 8 - 1))
  321. #define alt_max_long (~(alt_min_long))
  322.     static const double min_int_real = (alt_min_long * 1.0 - 1);
  323.     static const double max_int_real = (alt_max_long * 1.0 + 1);
  324.     double num;
  325.     int code = double_params(op, 1, &num);
  326.     if ( code < 0 )
  327.       return code;
  328.  
  329.     if ( num < min_int_real || num > max_int_real )
  330.       return_error(e_rangecheck);
  331.     make_int(op, (long)num);    /* truncates toward 0 */
  332.     return 0;
  333. }
  334.  
  335. /* <dnum> .dcvr <real> */
  336. private int
  337. zdcvr(os_ptr op)
  338. {
  339. #define b30 (0x40000000L * 1.0)
  340. #define max_mag (0xffffff * b30 * b30 * b30 * 0x4000)
  341.     static const float min_real = -max_mag;
  342.     static const float max_real = max_mag;
  343. #undef b30
  344. #undef max_mag
  345.     double num;
  346.     int code = double_params(op, 1, &num);
  347.     if ( code < 0 )
  348.       return code;
  349.     if ( num < min_real || num > max_real )
  350.       return_error(e_rangecheck);
  351.     make_real(op, (float)num);
  352.     return 0;
  353. }
  354.  
  355. /* <dnum> <string> .dcvs <substring> */
  356. private int
  357. zdcvs(os_ptr op)
  358. {    double num;
  359.     int code = double_params(op - 1, 1, &num);
  360.     char str[max_chars + 1];
  361.     int len;
  362.  
  363.     if ( code < 0 )
  364.       return code;
  365.     check_write_type(*op, t_string);
  366.     /*
  367.      * To get fully accurate output results for IEEE double-
  368.      * precision floats (53 bits of mantissa), the ANSI
  369.      * %g default of 6 digits is not enough; 16 are needed.
  370.      * Unfortunately, using %.16g produces unfortunate artifacts such as
  371.      * 1.2 printing as 1.200000000000005.  Therefore, we print using %g,
  372.      * and if the result isn't accurate enough, print again
  373.      * using %.16g.
  374.      */
  375.        {    double scanned;
  376.         sprintf(str, "%g", num);
  377.         sscanf(str, "%lf", &scanned);
  378.         if ( scanned != num )
  379.           sprintf(str, "%.16g", num);
  380.        }
  381.     len = strlen(str);
  382.     if ( len > r_size(op) )
  383.       return_error(e_rangecheck);
  384.     memcpy(op->value.bytes, str, len);
  385.     op[-1] = *op;
  386.     r_set_size(op - 1, len);
  387.     pop(1);
  388.     return 0;
  389. }
  390.  
  391. /* ------ Initialization table ------ */
  392.  
  393. BEGIN_OP_DEFS(zdouble_op_defs) {
  394.         /* Arithmetic */
  395.     {"3.dadd", zdadd},
  396.     {"3.ddiv", zddiv},
  397.     {"3.dmul", zdmul},
  398.     {"3.dsub", zdsub},
  399.         /* Simple functions */
  400.     {"2.dabs", zdabs},
  401.     {"2.dceiling", zdceiling},
  402.     {"2.dfloor", zdfloor},
  403.     {"2.dneg", zdneg},
  404.     {"2.dround", zdround},
  405.     {"2.dsqrt", zdsqrt},
  406.     {"2.dtruncate", zdtruncate},
  407.         /* Transcendental functions */
  408.     {"2.darccos", zdarccos},
  409.     {"2.darcsin", zdarcsin},
  410.     {"3.datan", zdatan},
  411.     {"2.dcos", zdcos},
  412.     {"3.dexp", zdexp},
  413.     {"2.dln", zdln},
  414.     {"2.dlog", zdlog},
  415.     {"2.dsin", zdsin},
  416.         /* Comparison */
  417.     {"2.deq", zdeq},
  418.     {"2.dge", zdge},
  419.     {"2.dgt", zdgt},
  420.     {"2.dle", zdle},
  421.     {"2.dlt", zdlt},
  422.     {"2.dne", zdne},
  423.         /* Conversion */
  424.     {"2.cvd", zcvd},
  425.     {"2.cvsd", zcvsd},
  426.     {"1.dcvi", zdcvi},
  427.     {"1.dcvr", zdcvr},
  428.     {"2.dcvs", zdcvs},
  429. END_OP_DEFS(0) }
  430.  
  431. /* ------ Internal procedures ------ */
  432.  
  433. /* Get some double arguments. */
  434. private int near
  435. double_params(os_ptr op, int count, double *pval)
  436. {    pval += count;
  437.     while ( --count >= 0 )
  438.        {    switch ( r_type(op) )
  439.            {
  440.         case t_real:
  441.             *--pval = op->value.realval;
  442.             break;
  443.         case t_integer:
  444.             *--pval = op->value.intval;
  445.             break;
  446.         case t_string:
  447.             if ( !r_has_attr(op, a_read) ||
  448.                  r_size(op) != sizeof(double)
  449.                )
  450.               return_error(e_typecheck);
  451.             --pval;
  452.             memcpy(pval, op->value.bytes, sizeof(double));
  453.             break;
  454.         case t__invalid:
  455.             return_error(e_stackunderflow);
  456.         default:
  457.             return_error(e_typecheck);
  458.            }
  459.         op--;
  460.        }
  461.     return 0;
  462. }
  463.  
  464. /* Get some double arguments, and check for a double result. */
  465. private int near
  466. double_params_result(os_ptr op, int count, double *pval)
  467. {    check_write_type(*op, t_string);
  468.     if ( r_size(op) != sizeof(double) )
  469.       return_error(e_typecheck);
  470.     return double_params(op - 1, count, pval);
  471. }
  472.  
  473. /* Return a double result. */
  474. private int near
  475. double_result(os_ptr op, int count, double result)
  476. {    os_ptr op1 = op - count;
  477.     ref_assign_inline(op1, op);
  478.     memcpy(op1->value.bytes, &result, sizeof(double));
  479.     pop(count);
  480.     return 0;
  481. }
  482.  
  483. /* Apply a unary function to a double operand. */
  484. private int near
  485. double_unary(os_ptr op, double (*func)(P1(double)))
  486. {    dbegin_unary();
  487.     return double_result(op, 1, (*func)(num));
  488. }
  489.